package pe.com.nextel.util;

/**
 * Resizable-array implementation of the <tt>List</tt> interface.  Implements
 * all optional list operations, and permits all elements, including
 * <tt>null</tt>.  In addition to implementing the <tt>List</tt> interface,
 * this class provides methods to manipulate the size of the array that is
 * used internally to store the list.  (This class is roughly equivalent to
 * <tt>Vector</tt>, except that it is unsynchronized.)<p>
 *
 * The <tt>size</tt>, <tt>isEmpty</tt>, <tt>get</tt>, <tt>set</tt>,
 * <tt>iterator</tt>, and <tt>listIterator</tt> operations run in constant
 * time.  The <tt>add</tt> operation runs in <i>amortized constant time</i>,
 * that is, adding n elements requires O(n) time.  All of the other operations
 * run in linear time (roughly speaking).  The constant factor is low compared
 * to that for the <tt>LinkedList</tt> implementation.<p>
 *
 * Each <tt>ArrayList</tt> instance has a <i>capacity</i>.  The capacity is
 * the size of the array used to store the elements in the list.  It is always
 * at least as large as the list size.  As elements are added an ArrayList,
 * its capacity grows automatically.  The details of the growth policy are not
 * specified beyond the fact that adding an element has constant amortized
 * time cost.<p> 
 *
 * An application can increase the capacity of an <tt>ArrayList</tt> instance
 * before adding a large number of elements using the <tt>ensureCapacity</tt>
 * operation.  This may reduce the amount of incremental reallocation.<p>
 *
 * <strong>Note that this implementation is not synchronized.</strong> If
 * multiple threads access an <tt>ArrayList</tt> instance concurrently, and at
 * least one of the threads modifies the list structurally, it <i>must</i> be
 * synchronized externally.  (A structural modification is any operation that
 * adds or deletes one or more elements, or explicitly resizes the backing
 * array; merely setting the value of an element is not a structural
 * modification.)  This is typically accomplished by synchronizing on some
 * object that naturally encapsulates the list.  If no such object exists, the
 * list should be "wrapped" using the <tt>Collections.synchronizedList</tt>
 * method.  This is best done at creation time, to prevent accidental
 * unsynchronized access to the list:
 * <pre>
 *	List list = Collections.synchronizedList(new ArrayList(...));
 * </pre><p>
 *
 * The iterators returned by this class's <tt>iterator</tt> and
 * <tt>listIterator</tt> methods are <i>fail-fast</i>: if list is structurally
 * modified at any time after the iterator is created, in any way except
 * through the iterator's own remove or add methods, the iterator will throw a
 * ConcurrentModificationException.  Thus, in the face of concurrent
 * modification, the iterator fails quickly and cleanly, rather than risking
 * arbitrary, non-deterministic behavior at an undetermined time in the
 * future.
 *
 * @author  Josh Bloch
 * @author  eespinoza
 * @version 1.26, 02/06/02
 * @see	    List
 * @see	    Vector
 * @since 1.3
 */
public class ArrayList extends AbstractList implements List {

    /**
	 * The array buffer into which the elements of the ArrayList are stored. The
	 * capacity of the ArrayList is the length of this array buffer.
	 */
    private transient Object elementData[];

    /**
	 * The size of the ArrayList (the number of elements it contains).
	 *
	 * @serial
	 */
    private int size;

    /**
	 * Constructs an empty list with an initial capacity of ten.
	 */
    public ArrayList() {
        this( 10 );
    }

    /**
	 * Constructs an empty list with the specified initial capacity.
	 *
	 * @param initialCapacity
	 *            the initial capacity of the list.
	 * @exception IllegalArgumentException
	 *                if the specified initial capacity is negative
	 */
    public ArrayList( int initialCapacity ) {
        super();
        
        if ( initialCapacity < 0 ) {
            throw new IllegalArgumentException( "Illegal Capacity: " + initialCapacity );
        }
        this.elementData = new Object[ initialCapacity ];
    }

    /**
	 * Returns the element at the specified position in this list.
	 *
	 * @param index
	 *            index of element to return.
	 * @return the element at the specified position in this list.
	 * @throws IndexOutOfBoundsException
	 *             if index is out of range <tt>(index
	 * 		  &lt; 0 || index &gt;= size())</tt>.
	 */
    public Object get( int index ) {
        RangeCheck( index );

        return elementData[index];
    }

    /**
	 * Replaces the element at the specified position in this list with the
	 * specified element.
	 *
	 * @param index
	 *            index of element to replace.
	 * @param element
	 *            element to be stored at the specified position.
	 * @return the element previously at the specified position.
	 * @throws IndexOutOfBoundsException
	 *             if index out of range
	 *             <tt>(index &lt; 0 || index &gt;= size())</tt>.
	 */
    public void set( int index, Object element ) {
        RangeCheck( index );

        elementData[index] = null;
        elementData[index] = element;
    }

    /**
	 * Appends the specified element to the end of this list.
	 *
	 * @param o
	 *            element to be appended to this list.
	 * @return <tt>true</tt> (as per the general contract of Collection.add).
	 */
    public void add( Object o ) {
        ensureCapacity( size + 1 ); // Increments modCount!!
        elementData[size++] = o;
    }

    /**
	 * Increases the capacity of this <tt>ArrayList</tt> instance, if
	 * necessary, to ensure that it can hold at least the number of elements
	 * specified by the minimum capacity argument.
	 *
	 * @param minCapacity
	 *            the desired minimum capacity.
	 */
    public void ensureCapacity( int minCapacity ) {
        // modCount++;
        int oldCapacity = elementData.length;
        if ( minCapacity > oldCapacity ) {
            Object oldData[] = elementData;
            int newCapacity = ( oldCapacity * 3 ) / 2 + 1;
            if ( newCapacity < minCapacity ) {
                newCapacity = minCapacity;
            }
            elementData = new Object[ newCapacity ];
            System.arraycopy( oldData, 0, elementData, 0, size );
           // System.out.println( "copie todo" );
        }
    }

    /**
	 * Check if the given index is in range. If not, throw an appropriate
	 * runtime exception. This method does *not* check if the index is negative:
	 * It is always used immediately prior to an array access, which throws an
	 * ArrayIndexOutOfBoundsException if index is negative.
	 */
    private void RangeCheck( int index ) {
        if ( index >= size ) {
            throw new IndexOutOfBoundsException( "Index: " + index + ", Size: " + size );
        }
    }

    /**
	 * Returns the number of elements in this list.
	 *
	 * @return the number of elements in this list.
	 */
    public int size() {
        return size;
    }

    /**
	 * Tests if this list has no elements.
	 *
	 * @return <tt>true</tt> if this list has no elements; <tt>false</tt>
	 *         otherwise.
	 */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
	 * Removes the element at the specified position in this list. Shifts any
	 * subsequent elements to the left (subtracts one from their indices).
	 *
	 * @param index
	 *            the index of the element to removed.
	 * @return the element that was removed from the list.
	 * @throws IndexOutOfBoundsException
	 *             if index out of range <tt>(index
	 * 		  &lt; 0 || index &gt;= size())</tt>.
	 */
    public void remove( int index ) {
        RangeCheck( index );

        // modCount++;
		// Object oldValue = elementData[index];

        int numMoved = size - index - 1;
        if ( numMoved > 0 ) {
            System.arraycopy( elementData, index + 1, elementData, index,
                    numMoved );
        }
        elementData[--size] = null; // Let gc do its work

    // return oldValue;
    }

    /**
	 * Removes all of the elements from this list. The list will be empty after
	 * this call returns.
	 */
    public void clear() {
        // modCount++;

        // Let gc do its work
        for ( int i = 0; i < size; i++ ) {
            elementData[i] = null;
        }

        size = 0;
    }

    /**
	 * Returns an array containing all of the elements in this list in the
	 * correct order.
	 *
	 * @return an array containing all of the elements in this list in the
	 *         correct order.
	 */
    public Object[] toArray() {
        Object[] result = new Object[ size ];
        System.arraycopy( elementData, 0, result, 0, size );
        return result;
    }

//    public static void main( String[] args ) {
//        ArrayList array = new ArrayList();
//        System.out.println( "array=" + array.size() );
//        for ( int i = 0; i < 50; i++ ) {
//            String str = new String( "hola" + i );
//            array.add( str );
//        }
//        System.out.println( "array=" + array.size() );
//        array.set( 3, "adicionado" );
//        for ( int i = 0; i < array.size(); i++ ) {
//            System.out.println( array.get( i ) );
//        }
//        array.remove( 1 );
//        // array.clear();
//
//        System.out.println( "array=" + array.size() );
//    }

    /**
     * Returns the last component of the list.
     *
     * @return  the last component of the vector, i.e., the component at index
     *          <code>size()&nbsp;-&nbsp;1</code>.
     * @exception  NoSuchElementException  if this vector is empty.
     */
    public Object lastElement() {
        if ( size == 0 ) {
            throw new RuntimeException();
        }
        return elementData[size - 1];
    }

 
}
